motion_provider.h

Go to the documentation of this file.

// WOLF - Copyright (C) 2020-2026
// Institut de Robòtica i Informàtica Industrial, CSIC-UPC.
// Authors: Joan Solà Ortega (jsola@iri.upc.edu) and
// Joan Vallvé Navarro (jvallve@iri.upc.edu)
// All rights reserved.
//
// This file is part of WOLF: http://www.iri.upc.edu/wolf
// WOLF is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 3
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
 
#include "core/common/wolf.h"
#include "core/composite/vector_composite.h"
#include "core/composite/type_composite.h"
#include "yaml-cpp/yaml.h"
 
namespace wolf
{
class TimeStamp;
 
WOLF_PTR_TYPEDEFS(MotionProvider);
 
class MotionProvider
{
  public:
    MotionProvider(const TypeComposite& _state_types, const YAML::Node& _params);
 
    virtual ~MotionProvider();
 
    // Queries to the processor
    virtual TimeStamp getTimeStamp() const = 0;
 
    virtual VectorComposite getState(StateKeys _keys = "") const = 0;
 
    virtual VectorComposite getState(const TimeStamp& _ts, StateKeys _keys = "") const = 0;
 
    VectorComposite getOdometry() const;
 
    void setOdometry(const VectorComposite&);
 
    bool isStateProvider() const;
 
    unsigned int getOrder() const;
 
    void setOrder(unsigned int);
 
  protected:
    void addTypes(const TypeComposite& _state_types);
 
    bool         is_state_provider_;     
    unsigned int state_provider_order_;  
 
  private:
    TypeComposite      state_types_;   
    VectorComposite    odometry_;      
    mutable std::mutex mut_odometry_;  
};
 
}  // namespace wolf
 
namespace wolf
{
inline MotionProvider::~MotionProvider() {}
 
inline bool MotionProvider::isStateProvider() const
{
    return is_state_provider_;
}
 
inline unsigned int MotionProvider::getOrder() const
{
    if (not isStateProvider())
        throw std::runtime_error("MotionProvider::getOrder: not a motion provider, doesn't have order");
    return state_provider_order_;
}
 
inline void MotionProvider::setOrder(unsigned int _order)
{
    if (not isStateProvider())
        throw std::runtime_error("MotionProvider::getOrder: not a motion provider, cannot have order");
    state_provider_order_ = _order;
}
 
} /* namespace wolf */